#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "image.h"
#include "extradialog.h"
#include "wizard.h"
#include <QPainter>
#include <QMessageBox>
#include <QColorDialog>
#include <QSize>
#include <QFileDialog>

#define M_PI 3.14159

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),CollageWindow(),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);

    pixCollage = new QPixmap();
    collageCreated = false;

    //On crée notre list personnalisé
    listPhotos = new MyListPhotos(this, 300, 430,ui->photos_groupbox);

    //Placement de la liste dans l'interface (on retire dabord le layout contenant les boutons + - et vider)
    ui->verticalLayout_12->removeItem(ui->horizontalLayout);
    ui->verticalLayout_12->addWidget(listPhotos, 1);
    ui->verticalLayout_12->addItem(ui->horizontalLayout);

    //on connecte le changement de selection de la listePhoto sur le slot de la fenetre
    connect(listPhotos,SIGNAL(itemSelectionChanged()),SLOT(item_selection_changed()));

    //On prévient l'user que l'app est lancée
    showMessage("Application lancée");

    //Initialisation des boutons retire, clean et du label nbr de photos
    on_update_delete();

    //On affiche par défaut la forme rectangle
    on_rectangle_radioButton_clicked();

    //On sélectionne le radiobutton rectangle
    ui->rectangle_radioButton->setChecked(true);

    //Initialisation des paramètres
    refreshParams(all, true, true);
}

/*Destructeur*/
MainWindow::~MainWindow()
{
    delete ui;
}

///////////PARAMETRES////////////
/**
*gére l'accessibilitée des paramètres et leurs valeurs
*/
void MainWindow::refreshParams(TypeParam param, bool updateEnable, bool updateContent)
{
    //on récupère le paramètre qui sera traité automatiquement
    TypeParam paramAuto = this->params->getAutoParam();

    ////////////taille collage///////////
    if(param == all || param == resultSizeId)
    {
        if(updateContent)
        {
            ui->hauteurEdit->setValue(params->getResultSize().height());
            ui->largeurEdit->setValue(params->getResultSize().width());
            ui->formatComboBox->setCurrentIndex(params->getFormatResult());
        }
        if(updateEnable)
        {
            if(paramAuto == resultSizeId)
            {
                ui->modeTailleCollageButton->setText("Auto");
                ui->hauteurEdit->setEnabled(false);
                ui->hauteurLabel->setEnabled(false);
                ui->largeurEdit->setEnabled(false);
                ui->largeurLabel->setEnabled(false);
                ui->formatComboBox->setEnabled(false);
            }
            else
            {
                ui->modeTailleCollageButton->setText("Manual");
                ui->hauteurEdit->setEnabled(true);
                ui->hauteurLabel->setEnabled(true);
                ui->largeurEdit->setEnabled(true);
                ui->largeurLabel->setEnabled(true);
                ui->formatComboBox->setEnabled(true);
            }
        }
    }

    ////////////taille photo///////////
    if(param == all || param == pictureSizeId)
    {
        if(updateContent)
        {
            ui->taillePhotoEdit->setValue(params->getPictureSize());
            ui->formatTaillePhotoComboBox->setCurrentIndex(params->getFormatPictureSize());
        }
        if(updateEnable)
        {
            if(paramAuto == pictureSizeId)
            {
                ui->modeTaillePhotoButton->setText("Auto");
                ui->taillePhotoEdit->setEnabled(false);
                ui->formatTaillePhotoComboBox->setEnabled(false);
            }
            else
            {
                ui->modeTaillePhotoButton->setText("Manual");
                ui->taillePhotoEdit->setEnabled(true);
                ui->formatTaillePhotoComboBox->setEnabled(true);
            }
        }
    }

    ////////////nombre photo///////////
    if(param == all || param == pictureQuantityId)
    {
        if(updateContent)
        {
            ui->nPhotosEdit->setValue(params->getPictureQuantity());
        }
        if(updateEnable)
        {
            if(paramAuto == pictureQuantityId)
            {
                ui->modeNombrePhotosButton->setText("Auto");
                ui->toutRadioButton->setEnabled(false);
                ui->nPhotosRadioButton->setEnabled(false);
                ui->nPhotosEdit->setEnabled(false);
                ui->nombre_photo_label_cb->setEnabled(false);
            }
            else
            {
                ui->modeNombrePhotosButton->setText("Manual");
                ui->toutRadioButton->setEnabled(true);
                ui->nPhotosRadioButton->setEnabled(true);
                ui->nPhotosEdit->setEnabled(true);
                ui->nombre_photo_label_cb->setEnabled(true);
                if(params->getAddAllPicture() == true)
                {
                    ui->toutRadioButton->setChecked(true);
                    ui->nPhotosRadioButton->setChecked(false);
                }
                else
                {
                    ui->toutRadioButton->setChecked(false);
                    ui->nPhotosRadioButton->setChecked(true);
                }
            }
        }
    }

    ///////////Distance entre les photos/////////////
    if(param == all || param == pictureDistanceId)
    {
        if(updateContent)
        {
            ui->DistanceSlider->setValue(params->getPictureDistance());
            ui->pourcentSpinBox->setValue(params->getPictureDistance());
        }
        if(updateEnable)
        {
            if(paramAuto == pictureDistanceId)
            {
                ui->modeDistanceButton->setText("Auto");
                ui->DistanceSlider->setEnabled(false);
                ui->pourcentSpinBox->setEnabled(false);
                ui->pourcentLabel->setEnabled(false);
            }
            else
            {
                ui->modeDistanceButton->setText("Manual");
                ui->DistanceSlider->setEnabled(true);
                ui->pourcentSpinBox->setEnabled(true);
                ui->pourcentLabel->setEnabled(true);
            }
        }
    }

    ///////////Bordure//////////////////////////////
    ui->NUDSizeBordure->setValue(params->getSizeBordure());
    ui->SLSizeBordure->setValue(params->getSizeBordure());
    QString qss = QString("background-color: %1").arg(this->params->getColorBordure().name());
    ui->BColorBordure->setStyleSheet(qss);
}

                            /*Distance photo*/
/**
 *slider distance photo
 */
void MainWindow::on_DistanceSlider_sliderMoved(int position)
{
    params->setPictureDistance(position);
    refreshParams(pictureDistanceId, false, true);
}

/**
 *combobox distance photo
 */
void MainWindow::on_pourcentSpinBox_valueChanged(int arg1)
{
    params->setPictureDistance(arg1);
    refreshParams(pictureDistanceId, false, true);
}

/**
 *clic sur auto-manuel distance photo
 */
void MainWindow::on_modeDistanceButton_clicked()
{
    //Si c'était le paramètre automatique
    if(this->params->getAutoParam() == pictureDistanceId)
    {
        //le nouveau paramètre automatique sera la taille du collage
        this->params->setAutoParam(resultSizeId);

        //On rafraichit la form
        refreshParams(all, true, false);
    }
    else
    {
        //la distance entre les images sera géré automatiquement
        this->params->setAutoParam(pictureDistanceId);

        //on rafraichit la form
        refreshParams(all, true, false);
    }
}

                            /*Nombre photo*/
/**
 *Clic sur auto-manuel nombre photo
 */
void MainWindow::on_modeNombrePhotosButton_clicked()
{
    //Si c'était le paramètre automatique
    if(this->params->getAutoParam() == pictureQuantityId)
    {
        //le nouveau paramètre automatique sera la taille du collage
        this->params->setAutoParam(resultSizeId);

        //On rafraichit la form
        refreshParams(all, true, false);
    }
    else
    {
        //la distance entre les images sera géré automatiquement
        this->params->setAutoParam(pictureQuantityId);

        //on rafraichit la form
        refreshParams(all, true, false);
    }
}

/**
 *clic radioboutton tout
 */
void MainWindow::on_toutRadioButton_clicked()
{
    //on met a jour le paramètre ajouter toutes les images
    this->params->setAddAllPicture(true);

    //on rafraichit la form
    refreshParams(all, true, false);
}

/**
 *clic radioboutton nbr photo
 */
void MainWindow::on_nPhotosRadioButton_clicked()
{
    //on met a jour le paramètre ajouter toutes les images
    this->params->setAddAllPicture(false);

    //on rafraichit la form
    refreshParams(all, true, false);
}

/**
 *changement nbr photo manuel
 */
void MainWindow::on_nPhotosEdit_editingFinished()
{
    this->params->setPictureQuantity(ui->nPhotosEdit->value());
    this->refreshParams(pictureQuantityId, false, true);
}

                            /*Taille photo*/
/**
 *Clic sur auto-manuel taille photo
 */
void MainWindow::on_modeTaillePhotoButton_clicked()
{
    //Si c'était le paramètre automatique
    if(this->params->getAutoParam() == pictureSizeId)
    {
        //le nouveau paramètre automatique sera la taille du collage
        this->params->setAutoParam(resultSizeId);

        //On rafraichit la form
        refreshParams(all, true, false);
    }
    else
    {
        //la distance entre les images sera géré automatiquement
        this->params->setAutoParam(pictureSizeId);

        //on rafraichit la form
        refreshParams(all, true, false);
    }
}

/**
 *changement taille photo manuelle
 */
void MainWindow::on_taillePhotoEdit_editingFinished()
{
    this->params->setPictureSize(ui->taillePhotoEdit->value());
    this->refreshParams(pictureSizeId, false, true);
}

/**
 *Changement format taille photo
 */
void MainWindow::on_formatTaillePhotoComboBox_currentIndexChanged(int index)
{
    params->setFormatPictureSize((Format)index);
    refreshParams(pictureSizeId, false, true);
}

                            /*Taille collage*/
/**
 * la taille du collage est automatique
 */
void MainWindow::on_modeTailleCollageButton_clicked()
{
    //Si c'était le paramètre automatique
    if(this->params->getAutoParam() == resultSizeId)
    {
        //le nouveau paramètre automatique sera la taille du collage
        this->params->setAutoParam(pictureSizeId);

        //On rafraichit la form
        refreshParams(all, true, false);
    }
    else
    {
        //la distance entre les images sera géré automatiquement
        this->params->setAutoParam(resultSizeId);

        //on rafraichit la form
        refreshParams(all, true, false);
    }
}

/**
 *changement width taille collage
 */
void MainWindow::on_largeurEdit_editingFinished()
{
    this->params->setResultWidth(ui->largeurEdit->value());
    refreshParams(resultSizeId, false, true);
}

/**
 *changement height taille collage
 */
void MainWindow::on_hauteurEdit_editingFinished()
{
    this->params->setResultHeight(ui->hauteurEdit->value());
    refreshParams(resultSizeId, false, true);
}

/**
 *Changement format taille collage
 */
void MainWindow::on_formatComboBox_currentIndexChanged(int index)
{
    params->setFormatResult((Format)index);
    refreshParams(resultSizeId, false, true);
}

                            /*bouton paramètre par défaut*/
/**
 *clic bouton paramètre par défaut
 */
void MainWindow::on_restaureButton_clicked()
{
    this->params = new Parametre();
    refreshParams(all, true, true);
}
/////////////AUTRES/////////////
/**
 *Sauvegarde (bouton créer)
 */
void MainWindow::on_creerButton_clicked()
{
    if(params->getListImage().count() ==0)
        return;

    if(!collageCreated)
    {
        //création du pixmap
        on_apercuButton_clicked();
    }

    QString fn = QFileDialog::getSaveFileName(this, tr("Save as..."),QString(), tr("PNG (*.png);;JPEG (*.jpg)"));
    if (fn.isEmpty())
        return;
    if (! (fn.endsWith(".png", Qt::CaseInsensitive) || fn.endsWith(".jpg", Qt::CaseInsensitive)))
        fn += ".png"; // default;

    //sauvegarde du pixmap
    pixCollage->save(fn);
}

/**
 *Boutton apperçu (bouton apercu)
 */
void MainWindow::on_apercuButton_clicked()
{
    if(params->getListImage().count() ==0)
        return;
    pixCollage = this->Collage();
    QPixmap pixCollageResize = pixCollage->scaled(ui->apercuLabel->size(), Qt::KeepAspectRatio,Qt::SmoothTransformation);
    ui->apercuLabel->setPixmap(pixCollageResize);
    collageCreated = true;
}

/**
 *Maj statusBar
 */
void MainWindow::showMessage(QString s)
{
    ui->statusBar->showMessage(s);
}

/////////////FORMES/////////////
/**
 *Fenetre de dessin de forme personalisée (radiobouton extra)
 */
void MainWindow::on_extra_radioButton_clicked()
{
    int width = ui->largeurEdit->value();
    int height = ui->hauteurEdit->value();

    //Initialisation de la boite de dialogue
    ExtraDialog extra(width,height,this);

    //Exécution de la boite de dialogue
    extra.exec();

    //on récupère le polygone et la pixmap
    polygon = extra.GetPolygon();
    QPixmap *pixmap = extra.GetCopyOfPixmap();

    //on affiche le pixmap dans la zone d'appercu
    setApercu(pixmap);

    delete(pixmap);
}

/**
 *Fonction permettant de cocher le radioBouton Extra (accès externe)
 */
void MainWindow::checkExtra(bool b)
{
    ui->extra_radioButton->setChecked(b);
}

/**
 *Création du cercle (radioboutton cercle)
 */
void MainWindow::on_cercle_radioButton_clicked()
{
    ui->cercle_radioButton->setChecked(true);
    SetCercle();
    QPixmap* pixmap = GetPolygonePixmap(polygon);
    setApercu(pixmap);
}

/**
 *Création du rectangle (radioboutton rectangle)
 */
void MainWindow::on_rectangle_radioButton_clicked()
{
    ui->rectangle_radioButton->setChecked(true);
    SetRectangle();
    QPixmap* pixmap = GetPolygonePixmap(polygon);
    setApercu(pixmap);
}

/**
 *Fonction permettant de mettre un miniature d'un pixmap dans le label apercu
 */
void MainWindow::setApercu(QPixmap* p)
{
    //on redimensionne pour le mettre dans l'aperçu
    QPixmap pix2 = p->scaled(ui->formeLabel->size(), Qt::KeepAspectRatio,Qt::SmoothTransformation);

    ui->formeLabel->setPixmap(pix2);
}

/////////LISTE DE PHOTO/////////
/**
 *Ajout de photos (bouton +)
 */
void MainWindow::on_ajoutButton_clicked()
{
    ajoutPhotoParDialog(this);
}

/**
 *Suppression d'une photo de la liste (bouton -)
 */
void MainWindow::on_retireButton_clicked()
{
    supprimePhoto();
}

/**
 *Suppression de toute la liste (bouton clean)
 */
void MainWindow::on_cleanButton_clicked()
{
    supprimeLesPhotos();
}

/**
 *Mise à jour des boutons et du nombre de photos
 */
void MainWindow::on_update_delete()
{
    CollageWindow::on_update_delete();

    //on affiche le bouton retire si la liste n'est pas vide et si au moin 1 élément est sélectionné
    ui->retireButton->setEnabled(listPhotos->count()>0 && listPhotos->selectedItems().count()>0);

    //on affiche le bouton clean si la liste n'est pas vide
    ui->cleanButton->setEnabled(listPhotos->count()>0);

    //on affiche le nombre de photos
    ui->nbPhotosLabel->setText(QString::number(listPhotos->count()));
}

/**
 *???????
 */
void MainWindow::item_selection_changed()
{
    on_update_delete();
}

//////////BARRE DE MENU/////////
/**
 *Ajout photos via menu (menu -> fichier -> ajouter photo)
 */
void MainWindow::on_actionAjouter_des_photos_triggered()
{
    ajoutPhotoParDialog(this);
}

/**
 *Quitter
 */
void MainWindow::on_actionQuitter_triggered()
{
    close();
}

/**
 *Nouvelle image (menu->fichier->nouveau)
 */
void MainWindow::on_actionNouveau_triggered()
{
    ui->rectangle_radioButton->setChecked(true);
    on_cleanButton_clicked();
    on_rectangle_radioButton_clicked();
}

/**
 *lancement wizard
 */
void MainWindow::on_actionAide_la_cr_ation_triggered()
{
    this->listPhotos->setAcceptDrops(false);
    Wizard* wizard = new Wizard(this);
    wizard->exec();
    this->listPhotos->setAcceptDrops(true);
}

void MainWindow::on_BColorBordure_clicked()
{
    QColor col = QColorDialog::getColor(Qt::white, this);

    if(col.isValid())
    {
        this->params->setColorBordure(col);
        refreshParams(all, false, false);
    }
}

void MainWindow::on_SLSizeBordure_valueChanged(int value)
{
    this->params->setSizeBordure(value);
    refreshParams(all, false, false);
}

void MainWindow::on_NUDSizeBordure_valueChanged(int arg1)
{
    this->params->setSizeBordure(arg1);
    refreshParams(all, false, false);
}
